Page({
  data: {
    cartList: [], // 购物车列表
    totalPrice: 0, // 总价格
    totalCount: 0, // 商品总数量
    allChecked: false, // 是否全选
    editMode: false,  // 是否处于编辑模式
    loading: true,
    isLoggedIn: true
  },
  
  onLoad: function() {
    // 页面加载时的逻辑
  },
  
  onShow: function() {
    // 每次显示页面时获取最新购物车数据
    this.checkLoginStatus();
  },
  
  // 检查登录状态
  checkLoginStatus: function() {
    const app = getApp();
    const userInfo = app.globalData.userInfo;
    
    if (!userInfo) {
      // 未登录，获取本地购物车数据
      const cartUtils = require('../../utils/cartUtils');
      const localCartItems = cartUtils.getLocalCart();
      
      if (localCartItems && localCartItems.length > 0) {
        // 有本地购物车数据，显示出来
        this.setData({
          isLoggedIn: true, // 虽然未登录，但允许查看购物车
          cartList: localCartItems,
          loading: false
        });
        
        // 计算总价和总数量
        this.calculateTotal();
      } else {
        // 本地购物车为空，显示未登录提示
        this.setData({
          isLoggedIn: false,
          cartList: [],
          totalPrice: 0,
          totalCount: 0,
          loading: false
        });
      }
    } else {
      // 已登录，获取购物车数据
      this.setData({ isLoggedIn: true });
      this.getCartData();
    }
  },
  
  // 跳转到登录页面
  goToLogin: function() {
    const app = getApp();
    app.goToLogin('/pages/cart/cart');
  },
  
  // 获取购物车数据
  getCartData: function() {
    this.setData({ loading: true });
    
    const app = getApp();
    const userInfo = app.globalData.userInfo;
    
    // 检查是否登录
    if (!userInfo) {
      this.setData({ 
        cartList: [],
        totalPrice: 0,
        totalCount: 0,
        loading: false
      });
      return;
    }
    
    // 调用API获取购物车数据
    app.globalData.api.cart.getList()
      .then(res => {
        console.log('购物车数据返回:', res);
        
        // 处理图片URL，确保使用完整路径
        const cartList = (res.results || [])
          .filter(item => item.count > 0) // 过滤掉数量为0的商品
          .map(item => {
            if (item.food_info) {
              if (item.food_info.image_url) {
                // 优先使用服务器提供的完整URL
                item.food_info.image = item.food_info.image_url;
              } else if (item.food_info.image) {
                item.food_info.image = app.globalData.api.getFullImageUrl(item.food_info.image);
              }
            }
            return item;
          });
        
        this.setData({
          cartList: cartList,
          loading: false
        });
        
        // 计算总价和总数量
        this.calculateTotal();
      })
      .catch(err => {
        console.error('获取购物车数据失败', err);
        this.setData({ loading: false });
        
        wx.showToast({
          title: '获取数据失败',
          icon: 'none'
        });
      });
  },
  
  // 计算总价和总数量
  calculateTotal: function() {
    let totalPrice = 0;
    let totalCount = 0;
    let allChecked = true;
    
    this.data.cartList.forEach(item => {
      if (item.is_checked) {
        // 确保total_price是数字类型
        totalPrice += parseFloat(item.total_price || 0);
        totalCount += item.count;
      } else {
        allChecked = false;
      }
    });
    
    // 如果购物车为空，全选为false
    if (this.data.cartList.length === 0) {
      allChecked = false;
    }
    
    this.setData({
      totalPrice: totalPrice.toFixed(2),
      totalCount: totalCount,
      allChecked: allChecked
    });
  },
  
  // 切换编辑模式
  toggleEditMode: function() {
    this.setData({
      editMode: !this.data.editMode
    });
  },
  
  // 切换商品选中状态
  toggleItemCheck: function(e) {
    const index = e.currentTarget.dataset.index;
    const item = this.data.cartList[index];
    const app = getApp();
    const userInfo = app.globalData.userInfo;
    
    if (!item) {
      wx.showToast({
        title: '无法操作该商品',
        icon: 'none'
      });
      return;
    }
    
    const checked = !item.is_checked;
    
    // 检查是否为本地购物车
    if (item.is_local || !userInfo) {
      // 本地购物车，直接更新状态
      const cartUtils = require('../../utils/cartUtils');
      const localCartItems = cartUtils.getLocalCart();
      
      // 更新对应商品的选中状态
      const updatedItems = localCartItems.map(cartItem => {
        if (cartItem.food === item.food && 
            ((!item.spec && !cartItem.spec) || (item.spec && cartItem.spec && item.spec === cartItem.spec))) {
          cartItem.is_checked = checked;
        }
        return cartItem;
      });
      
      // 保存更新后的本地购物车
      wx.setStorageSync('local_cart_items', updatedItems);
      
      // 更新页面数据
      const cartList = this.data.cartList;
      cartList[index].is_checked = checked;
      
      this.setData({ cartList });
      this.calculateTotal();
      return;
    }
    
    // 已登录用户，调用API更新选中状态
    const cartItemId = parseInt(item.id);
    
    console.log('准备更新选中状态:', { cartItemId, checked });
    
    app.globalData.api.cart.update(cartItemId, { is_checked: checked })
      .then(res => {
        // 更新本地数据
        const cartList = this.data.cartList;
        cartList[index].is_checked = checked;
        
        this.setData({ cartList });
        this.calculateTotal();
      })
      .catch(err => {
        console.error('更新选中状态失败', err);
        wx.showToast({
          title: '操作失败',
          icon: 'none'
        });
      });
  },
  
  // 全选/取消全选
  toggleAllCheck: function() {
    const allChecked = !this.data.allChecked;
    const app = getApp();
    const userInfo = app.globalData.userInfo;
    
    // 检查是否使用本地购物车
    if (!userInfo || this.data.cartList.some(item => item.is_local)) {
      // 本地购物车，直接更新状态
      const cartUtils = require('../../utils/cartUtils');
      const localCartItems = cartUtils.getLocalCart();
      
      // 更新所有商品的选中状态
      const updatedItems = localCartItems.map(item => {
        item.is_checked = allChecked;
        return item;
      });
      
      // 保存更新后的本地购物车
      wx.setStorageSync('local_cart_items', updatedItems);
      
      // 更新页面数据
      const cartList = this.data.cartList.map(item => {
        item.is_checked = allChecked;
        return item;
      });
      
      this.setData({ 
        cartList,
        allChecked 
      });
      
      this.calculateTotal();
      return;
    }
    
    // 获取所有购物车项的ID
    const ids = this.data.cartList.map(item => item.id);
    
    // 调用API批量更新选中状态
    app.globalData.api.cart.batchUpdate({
      ids: ids,
      is_checked: allChecked
    })
      .then(res => {
        // 更新本地数据
        const cartList = this.data.cartList.map(item => {
          item.is_checked = allChecked;
          return item;
        });
        
        this.setData({ cartList, allChecked });
        this.calculateTotal();
      })
      .catch(err => {
        console.error('批量更新选中状态失败', err);
        wx.showToast({
          title: '操作失败',
          icon: 'none'
        });
      });
  },
  
  // 减少商品数量
  minusCount: function(e) {
    const index = e.currentTarget.dataset.index;
    const item = this.data.cartList[index];
    const app = getApp();
    const userInfo = app.globalData.userInfo;
    
    if (!item) {
      wx.showToast({
        title: '无法操作该商品',
        icon: 'none'
      });
      return;
    }
    
    // 处理本地购物车
    if (item.is_local || !userInfo) {
      const cartUtils = require('../../utils/cartUtils');
      
      if (item.count <= 1) {
        // 如果数量为1，从购物车中移除
        cartUtils.removeFromLocalCart(item.food, item.spec);
        
        // 更新页面数据
        const cartList = [...this.data.cartList];
        cartList.splice(index, 1);
        
        this.setData({ cartList });
        this.calculateTotal();
        
        // 如果购物车为空，更新状态
        if (cartList.length === 0) {
          this.setData({ 
            hasCartItems: false,
            allChecked: false 
          });
        }
        
        wx.showToast({
          title: '已移除商品',
          icon: 'success'
        });
      } else {
        // 减少数量
        cartUtils.updateLocalCartItemCount(item.food, item.count - 1, item.spec);
        
        // 更新页面数据
        const cartList = [...this.data.cartList];
        cartList[index].count -= 1;
        // 更新总价
        const unitPrice = parseFloat(cartList[index].unit_price || 0);
        cartList[index].total_price = (unitPrice * cartList[index].count).toFixed(2);
        
        this.setData({ cartList });
        this.calculateTotal();
        
        wx.showToast({
          title: '已减少数量',
          icon: 'success'
        });
      }
      return;
    }
    
    if (item.count <= 1) {
      // 如果数量为1，直接删除
      this.deleteItem(item.id, index);
      return;
    }
    
    // 调用API更新数量
    const cartItemId = parseInt(item.id);
    const newCount = item.count - 1;
    
    console.log('准备更新购物车:', { cartItemId, newCount });
    
    app.globalData.api.cart.update(cartItemId, { count: newCount })
      .then(res => {
        // 更新本地数据
        const cartList = this.data.cartList;
        cartList[index].count -= 1;
        // 确保unit_price是数字，计算结果也是数字
        const unitPrice = parseFloat(cartList[index].unit_price || 0);
        cartList[index].total_price = (unitPrice * cartList[index].count).toFixed(2);
        
        this.setData({ cartList });
        this.calculateTotal();
      })
      .catch(err => {
        console.error('更新数量失败', err);
        wx.showToast({
          title: '操作失败',
          icon: 'none'
        });
      });
  },
  
  // 增加商品数量
  addCount: function(e) {
    const index = e.currentTarget.dataset.index;
    const item = this.data.cartList[index];
    const app = getApp();
    const userInfo = app.globalData.userInfo;
    
    if (!item) {
      wx.showToast({
        title: '无法操作该商品',
        icon: 'none'
      });
      return;
    }
    
    // 处理本地购物车
    if (item.is_local || !userInfo) {
      const cartUtils = require('../../utils/cartUtils');
      
      // 增加数量
      cartUtils.updateLocalCartItemCount(item.food, item.count + 1, item.spec);
      
      // 更新页面数据
      const cartList = [...this.data.cartList];
      cartList[index].count += 1;
      // 更新总价
      const unitPrice = parseFloat(cartList[index].unit_price || 0);
      cartList[index].total_price = (unitPrice * cartList[index].count).toFixed(2);
      
      this.setData({ cartList });
      this.calculateTotal();
      
      wx.showToast({
        title: '已增加数量',
        icon: 'success'
      });
      return;
    }
    
    // 调用API更新数量
    const cartItemId = parseInt(item.id);
    const newCount = item.count + 1;
    
    console.log('准备更新购物车:', { cartItemId, newCount });
    
    app.globalData.api.cart.update(cartItemId, { count: newCount })
      .then(res => {
        // 更新本地数据
        const cartList = this.data.cartList;
        cartList[index].count += 1;
        // 确保unit_price是数字，计算结果也是数字
        const unitPrice = parseFloat(cartList[index].unit_price || 0);
        cartList[index].total_price = (unitPrice * cartList[index].count).toFixed(2);
        
        this.setData({ cartList });
        this.calculateTotal();
      })
      .catch(err => {
        console.error('更新数量失败', err);
        wx.showToast({
          title: '操作失败',
          icon: 'none'
        });
      });
  },
  
  // 删除商品
  deleteItem: function(id, index) {
    const app = getApp();
    const userInfo = app.globalData.userInfo;
    
    // 获取购物车项
    const item = this.data.cartList[index];
    
    // 处理本地购物车
    if ((item && item.is_local) || !userInfo) {
      const cartUtils = require('../../utils/cartUtils');
      
      // 从本地购物车中删除
      if (item) {
        cartUtils.removeFromLocalCart(item.food, item.spec);
      }
      
      // 更新页面数据
      const cartList = [...this.data.cartList];
      cartList.splice(index, 1);
      
      this.setData({ cartList });
      this.calculateTotal();
      
      // 如果购物车为空，更新状态
      if (cartList.length === 0) {
        this.setData({ 
          hasCartItems: false,
          allChecked: false 
        });
      }
      
      wx.showToast({
        title: '删除成功',
        icon: 'success'
      });
      return;
    }
    
    if (!id) {
      wx.showToast({
        title: '无法删除商品',
        icon: 'none'
      });
      return;
    }
    
    // 调用API删除购物车项，使用购物车项ID
    const cartItemId = parseInt(id);
    
    console.log('准备删除购物车项:', { cartItemId });
    
    app.globalData.api.cart.delete(cartItemId)
      .then(res => {
        // 更新本地数据
        const cartList = this.data.cartList;
        cartList.splice(index, 1);
        
        this.setData({ cartList });
        this.calculateTotal();
        
        wx.showToast({
          title: '删除成功',
          icon: 'success'
        });
      })
      .catch(err => {
        console.error('删除失败', err);
        wx.showToast({
          title: '删除失败',
          icon: 'none'
        });
      });
  },
  
  // 批量删除选中商品
  deleteSelected: function() {
    const selectedItems = this.data.cartList.filter(item => item.is_checked);
    const app = getApp();
    const userInfo = app.globalData.userInfo;
    
    if (selectedItems.length === 0) {
      wx.showToast({
        title: '请先选择商品',
        icon: 'none'
      });
      return;
    }
    
    wx.showModal({
      title: '提示',
      content: '确定要删除选中的商品吗？',
      success: (res) => {
        if (res.confirm) {
          // 处理本地购物车
          if (!userInfo || selectedItems.some(item => item.is_local)) {
            const cartUtils = require('../../utils/cartUtils');
            
            // 从本地购物车中移除选中项
            selectedItems.forEach(item => {
              if (item.is_local || !userInfo) {
                cartUtils.removeFromLocalCart(item.food, item.spec);
              }
            });
            
            // 更新页面数据
            const cartList = this.data.cartList.filter(item => !item.is_checked);
            
            this.setData({ 
              cartList,
              editMode: false
            });
            this.calculateTotal();
            
            // 如果购物车为空，更新状态
            if (cartList.length === 0) {
              this.setData({ 
                hasCartItems: false,
                allChecked: false 
              });
            }
            
            wx.showToast({
              title: '删除成功',
              icon: 'success'
            });
            return;
          }
          
          // 获取选中项的ID
          const ids = selectedItems.map(item => item.id);
          
          // 逐个删除选中项
          const deletePromises = ids.map(id => app.globalData.api.cart.delete(id));
          
          Promise.all(deletePromises)
            .then(() => {
              // 更新本地数据
              const cartList = this.data.cartList.filter(item => !item.is_checked);
              
              this.setData({ 
                cartList,
                editMode: false
              });
              this.calculateTotal();
              
              wx.showToast({
                title: '删除成功',
                icon: 'success'
              });
            })
            .catch(err => {
              console.error('批量删除失败', err);
              wx.showToast({
                title: '删除失败',
                icon: 'none'
              });
            });
        }
      }
    });
  },
  
  // 结算
  checkout: function() {
    const selectedItems = this.data.cartList.filter(item => item.is_checked);
    const app = getApp();
    const userInfo = app.globalData.userInfo;
    
    if (selectedItems.length === 0) {
      wx.showToast({
        title: '请先选择商品',
        icon: 'none'
      });
      return;
    }
    
    // 如果是本地购物车数据且未登录，需要先登录
    if (!userInfo) {
      // 跳转到登录页面，并指示登录后返回购物车页面
      wx.showModal({
        title: '温馨提示',
        content: '请先登录后再结算',
        confirmText: '去登录',
        success: (res) => {
          if (res.confirm) {
            app.goToLogin('/pages/cart/cart');
          }
        }
      });
      return;
    }
    
    // 如果有本地购物车数据，先同步到服务器
    const hasLocalItems = selectedItems.some(item => item.is_local);
    if (hasLocalItems) {
      const cartUtils = require('../../utils/cartUtils');
      wx.showLoading({
        title: '同步购物车...',
      });
      
      cartUtils.syncLocalCartToServer(app.globalData.api)
        .then(() => {
          wx.hideLoading();
          // 同步完成后，重新获取购物车数据并跳转到订单页
          this.getCartData();
          setTimeout(() => {
            wx.navigateTo({
              url: '/pages/order/order'
            });
          }, 500);
        })
        .catch(err => {
          wx.hideLoading();
          console.error('同步购物车失败', err);
          wx.showModal({
            title: '同步失败',
            content: '购物车数据同步失败，请重试',
            showCancel: false
          });
        });
      return;
    }
    
    // 跳转到订单确认页面
    wx.navigateTo({
      url: '/pages/order/order'
    });
  }
}) 